---
title: 对话机器人快速入门
description: Spring AI 对话机器人快速入门指南
sidebar_position: 1
---

# 对话机器人快速入门

本文将指导您如何使用 Spring AI 快速创建一个对话机器人应用。Spring AI 遵循与 OpenAI 一致的调用规范，使得开发者可以轻松地集成各种 AI 模型。

## 环境准备

在开始之前，请确保您已经准备好以下环境：

- JDK 17 或更高版本
- Maven 3.6+ 或 Gradle 7.0+
- IDE（推荐使用 IntelliJ IDEA 或 Spring Tool Suite）

## 使用 Spring AI 的三个步骤

使用 Spring AI 开发对话机器人应用主要包含三个步骤：

1. **引入依赖** - 添加 Spring AI 相关依赖
2. **配置模型** - 设置 API 密钥和模型参数
3. **配置客户端** - 创建并使用 AI 客户端进行调用

### 1. 引入依赖

Spring AI 提供了丰富的依赖管理选项，支持多种 AI 模型。依赖管理分为两个部分：

#### 1.1 添加 Spring AI BOM

首先，建议添加 Spring AI BOM (Bill of Materials) 来管理所有 Spring AI 相关依赖的版本：

**Maven**:

```xml
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.ai</groupId>
            <artifactId>spring-ai-bom</artifactId>
            <version>1.0.0-M6</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
```

**Gradle**:
```groovy
dependencies {
    implementation platform('org.springframework.ai:spring-ai-bom:1.0.0-M6')
}
```

使用 BOM 后，您可以在添加具体依赖时省略版本号，由 BOM 统一管理版本，避免版本冲突。

#### 1.2 添加具体模型依赖

Spring AI 支持多种 AI 模型，每种模型都有对应的 starter 依赖。以下是一些常用模型的依赖：

**OpenAI 模型**:
```xml
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>1.0.0-M6</version>
</dependency>
```

**其他支持的模型 starter**:

```xml
<!-- Azure OpenAI -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-azure-openai-spring-boot-starter</artifactId>
</dependency>

<!-- Anthropic Claude -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-anthropic-spring-boot-starter</artifactId>
</dependency>

<!-- Ollama -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
</dependency>

<!-- Hugging Face -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-huggingface-spring-boot-starter</artifactId>
</dependency>

<!-- 百度文心一言 -->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-baidu-spring-boot-starter</artifactId>
</dependency>
```

> 注意：如果您使用了 BOM，以上依赖可以省略版本号。

### 2. 配置模型

在 `application.properties` 或 `application.yml` 中配置 AI 模型：

```properties
spring.ai.openai.api-key=your-openai-api-key
spring.ai.openai.model=gpt-3.5-turbo
```

如果使用其他符合 OpenAI 规范的模型提供商（如 DeepSeek），可以这样配置：

```properties
spring.ai.openai.api-key=YOUR_DEEPSEEK_API_KEY
spring.ai.openai.base-url=https://api.deepseek.com
spring.ai.openai.model=deepseek-r1
```

### 3. 使用客户端

Spring AI 的调用方式与 OpenAI 的规范保持一致，下面是一个基本示例：

```java
import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ChatbotService {

    private final ChatClient chatClient;
    
    @Autowired
    public ChatbotService(ChatClient chatClient) {
        this.chatClient = chatClient;
    }
    
    public String chat(String userInput) {
        // 创建消息列表
        List<Message> messages = new ArrayList<>();
        
        // 添加系统消息
        messages.add(new SystemMessage("你是一个热心的AI助手，你的名字叫小团队"));
        
        // 添加用户消息
        messages.add(new UserMessage(userInput));
        
        // 创建提示
        Prompt prompt = new Prompt(messages);
        
        // 设置参数
        Map<String, Object> parameters = new HashMap<>();
        parameters.put("temperature", 0.7);
        parameters.put("stream", false);
        
        // 发送请求并获取响应
        ChatResponse response = chatClient.call(prompt, parameters);
        
        // 返回生成的内容
        return response.getResult().getOutput().getContent();
    }
}
```

## Spring AI 模型支持

Spring AI 提供了丰富的模型支持，每种模型都有对应的 starter 和配置方式：

| 模型提供商 | Starter 依赖 | 配置前缀 |
|------------|--------------|----------|
| OpenAI | spring-ai-openai-spring-boot-starter | spring.ai.openai |
| Azure OpenAI | spring-ai-azure-openai-spring-boot-starter | spring.ai.azure.openai |
| Anthropic Claude | spring-ai-anthropic-spring-boot-starter | spring.ai.anthropic |
| Ollama | spring-ai-ollama-spring-boot-starter | spring.ai.ollama |
| Hugging Face | spring-ai-huggingface-spring-boot-starter | spring.ai.huggingface |
| 百度文心一言 | spring-ai-baidu-spring-boot-starter | spring.ai.baidu |
| 讯飞星火 | spring-ai-spark-spring-boot-starter | spring.ai.spark |
| Vertex AI | spring-ai-vertex-ai-spring-boot-starter | spring.ai.vertex.ai |

## OpenAI 规范的调用示例

Spring AI 遵循 OpenAI 的调用规范，以下是一个 Python 示例，展示了与 Spring AI 相同的调用结构：

```python
from openai import OpenAI

# 1. 初始化OpenAI客户端
client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.deepseek.com"
)

# 2. 发送请求到大模型
response = client.chat.completions.create(
    model="deepseek-r1",
    temperature=0.7,
    messages=[
        {"role": "system", "content": "你是一个热心的AI助手，你的名字叫小团队"},
        {"role": "user", "content": "你好，你是谁？"}
    ],
    stream=False
)

# 3. 打印返回结果
print(response.choices[0].message.content)
```

## 完整的 Spring Boot 示例

下面是一个完整的 Spring Boot 应用示例，展示了如何使用 Spring AI 创建一个简单的对话机器人：

### 1. 创建服务类

```java
package com.example.chatbot.service;

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ChatbotService {

    private final ChatClient chatClient;
    
    @Autowired
    public ChatbotService(ChatClient chatClient) {
        this.chatClient = chatClient;
    }
    
    public String chat(String userInput) {
        // 创建消息列表
        List<Message> messages = new ArrayList<>();
        
        // 添加系统消息
        messages.add(new SystemMessage("你是一个热心的AI助手，你的名字叫小团队"));
        
        // 添加用户消息
        messages.add(new UserMessage(userInput));
        
        // 创建提示
        Prompt prompt = new Prompt(messages);
        
        // 设置参数
        Map<String, Object> parameters = new HashMap<>();
        parameters.put("temperature", 0.7);
        parameters.put("stream", false);
        
        // 发送请求并获取响应
        ChatResponse response = chatClient.call(prompt, parameters);
        
        // 返回生成的内容
        return response.getResult().getOutput().getContent();
    }
}
```

### 2. 创建控制器

```java
package com.example.chatbot.controller;

import com.example.chatbot.service.ChatbotService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/chat")
public class ChatbotController {

    private final ChatbotService chatbotService;

    @Autowired
    public ChatbotController(ChatbotService chatbotService) {
        this.chatbotService = chatbotService;
    }

    @PostMapping
    public ChatResponse chat(@RequestBody ChatRequest request) {
        String response = chatbotService.chat(request.getMessage());
        return new ChatResponse(response);
    }

    // 请求和响应的数据模型
    public static class ChatRequest {
        private String message;

        // Getter and Setter
        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }
    }

    public static class ChatResponse {
        private String reply;

        public ChatResponse(String reply) {
            this.reply = reply;
        }

        // Getter
        public String getReply() {
            return reply;
        }
    }
}
```

### 3. 配置 application.properties

```properties
# OpenAI 配置
spring.ai.openai.api-key=your-openai-api-key
spring.ai.openai.model=gpt-3.5-turbo

# 其他模型提供商配置示例
# spring.ai.openai.api-key=your-api-key
# spring.ai.openai.base-url=https://api.deepseek.com
# spring.ai.openai.model=deepseek-r1
```

## 模型参数说明

Spring AI 支持设置以下常用参数：

| 参数名 | 说明 | 示例值 |
|---------|---------|---------|
| model | 使用的模型名称 | gpt-3.5-turbo |
| temperature | 温度参数，控制输出的随机性 | 0.7 |
| max_tokens | 生成的最大令牌数 | 500 |
| stream | 是否使用流式响应 | false |
| messages | 消息列表，包含角色和内容 | 系统和用户消息 |

## 支持的模型提供商

Spring AI 支持多种符合 OpenAI 规范的模型提供商，包括：

- OpenAI (GPT-3.5, GPT-4)
- Azure OpenAI
- DeepSeek
- Anthropic Claude
- 百度文心一言
- 讯飞星火
- 等其他兼容 OpenAI API 的模型

## 下一步

在掌握了基本用法后，您可以：

1. 学习如何[添加会话记忆](./conversation-memory)，使机器人能够记住对话上下文
2. 探索[多模态功能](./multimodal)，让机器人处理图像等多种类型的输入
3. 了解更多关于[提示词工程](../simulator/prompt-engineering)的知识，优化机器人的回答质量

## 参考资料

- [Spring AI 官方文档](https://docs.spring.io/spring-ai/reference/)
- [OpenAI API 参考](https://platform.openai.com/docs/api-reference)
- [Spring AI GitHub 仓库](https://github.com/spring-projects/spring-ai)
